const express = require('express');
const router = express.Router();
const db = require('../db');
const { Op } = require('sequelize'); // 确保在顶部引入 Sequelize 的 Op 对象




// 定义config的闭环列表接口
// 该接口用于获取闭环列表，支持分页和动态查询
//GET /getAllCloseLoopList
router.get('/getAllCloseLoopList', async (req, res) => {
    try {
      // 构建分页查询的 SQL
      const sql = `
        SELECT 
          cl.close_loop_id, 
          cl.close_loop_name, 
          cl.close_loop_detail, 
          cl.close_type, 
          (SELECT COUNT(1) FROM close_loop_nodes n WHERE n.close_loop_id = cl.close_loop_id) AS node_count, 
          (SELECT COUNT(1) FROM close_loop_nodes n WHERE n.close_loop_id = cl.close_loop_id AND n.integrity_check = 1) AS integrity_count,
          (SELECT COUNT(1) FROM close_loop_nodes n WHERE n.close_loop_id = cl.close_loop_id AND n.before_node_id IS NOT NULL) AS time_count,
          cl.staff_id, 
          cl.staff_name, 
          da.advice_id, 
          da.advice_name 
        FROM close_loop cl 
        LEFT JOIN close_loop_doctor_advice da ON da.close_loop_id = cl.close_loop_id 
        ORDER BY cl.create_time DESC
      `;
  
      // 打印实际执行的 SQL
      console.log('实际执行的 SQL:', sql);
      // 执行查询并获取结果
      const results = await db.query(sql, { type: db.QueryTypes.SELECT });
  
       // 确定 rows 的正确来源
       let rows;
       if (Array.isArray(results) && results.length > 0) {
         // 如果 results 是直接返回的数组（如未包裹在 [rows, metadata] 中）
         rows = results;
       } else if (Array.isArray(results[0])) {
         // 如果 results 是 [rowsArray, metadata] 的形式
         rows = results[0];
       } else {
         // 处理意外情况
         rows = [];
       }
  
      // 验证数据类型和长度
      console.log('原始查询结果:', results); // 输出完整结构
      console.log('数据类型:', Array.isArray(rows) ? '数组' : '非数组');
      console.log('数据长度:', rows?.length); 
  
      // 直接返回原始数据
      res.json({
        code: 200,
        data: rows || [], // 返回原始数据
        message: '成功获取闭环列表'
      });
    } catch (error) {
      console.error('错误:', error);
      res.status(500).json({
        code: 500,
        message: '获取数据失败'
      });
    }
  });
  
  //获取指定闭环的基本信息
  //getCloseLoopDetailJb?CLOSE_LOOP_ID=3802CF7F66814B138B6399C4195C2354
  router.get('/getCloseLoopDetailJb', async (req, res) => {
    try {
      // 获取查询参数
      const closeLoopId = req.query.CLOSE_LOOP_ID;
  
      // 参数校验
      if (!closeLoopId) {
        return res.status(400).json({
          code: 400,
          message: 'Missing required parameter: CLOSE_LOOP_ID'
        });
      }
  
      // 执行参数化查询（防止SQL注入）
      const sql = `
        SELECT 
          A.CLOSE_LOOP_ID,
          B.USER_ID AS user_id,
          B.REALNAME AS realname,
          C.CLOSE_LOOP_NAME AS close_loop_name,
          C.CLOSE_LOOP_DETAIL AS close_loop_detail
        FROM LOOP_MAIN A
        LEFT JOIN USERS B ON A.USER_ID = B.USER_ID
        INNER JOIN CLOSE_LOOP C ON A.CLOSE_LOOP_ID = C.CLOSE_LOOP_ID
        WHERE A.CLOSE_LOOP_ID = :CLOSE_LOOP_ID
      `;
      console.log('实际执行的 SQL:', sql);
      // 使用参数化查询绑定值
      const replacements = { CLOSE_LOOP_ID: closeLoopId };
      const queryResult = await db.query(sql, {
        replacements,
        type: db.QueryTypes.SELECT
      });
  
      // 处理结果
      const data = queryResult[0] || null;
      if (!data) {
        return res.status(404).json({
          code: 404,
          message: 'No data found for this CLOSE_LOOP_ID'
        });
      }
  
      // 返回成功响应
      res.json({
        code: 200,
        data: data,
        message: '闭环基本信息获取成功'
      });
  
    } catch (error) {
      console.error('获取闭环基本信息获失败:', error);
      res.status(500).json({
        code: 500,
        message: 'Internal server error',
        error: error.message
      });
    }
  });
  // 获取闭环基本信息中用户信息接口
  router.get('/getUserInfo', async (req, res) => {
    try {
      // 获取查询参数
      const search = req.query.search?.trim(); 
  
      // 动态构建SQL语句
      let sql = 'SELECT USER_ID|| \'|\' ||REALNAME AS USER_XX FROM USERS';
      const replacements = {};
  
      if (search) {
        sql += ' WHERE REALNAME LIKE :search OR USER_ID LIKE :search';
        replacements.search = `%${search}%`; // 参数化查询，自动转义
      }
  
      // 执行查询
      const queryResult = await db.query(sql, {
        replacements,
        type: db.QueryTypes.SELECT
      });
  
      // 返回结果
      res.json({
        code: 200,
        data: queryResult,
        message: '用户列表获取成功'
      });
    } catch (error) {
      console.error('获取用户列表失败:', error);
      res.status(500).json({
        code: 500,
        message: '获取用户列表失败，请稍后再试'
      });
    }
  });





  
  //获取主闭环的医嘱主要信息
  //getCloseLoopDetailYz?CLOSE_LOOP_ID=3802CF7F66814B138B6399C4195C2354
  router.get('/getCloseLoopDetailYz', async (req, res) => {
    try {
      // 获取查询参数
      const closeLoopId = req.query.CLOSE_LOOP_ID;
  
      // 参数校验
      if (!closeLoopId) {
        return res.status(400).json({
          code: 400,
          message: 'Missing required parameter: CLOSE_LOOP_ID'
        });
      }
  
      // 执行参数化查询（防止SQL注入）
      // const sql = `
      //   SELECT 
      //         A.ADVICE_ID,
      //         A.CLOSE_LOOP_ID,
      //         A.ADVICE_NAME,
      //         A.DB_LINK_NAME,
      //         A.BASE_TABLE_NAME,
      //         A.JOIN_TABLE_SQL,
      //         A.WHERE_SQL,
      //         A.RESULT_SQL,
      //         B.COLUMN_NAME,
      //         B.COLUMN_SQL
              
      //         FROM CLOSE_LOOP_DOCTOR_ADVICE  A
      //   --LEFT JOIN CLOSE_ADVICE_JOIN_CONFIG B ON A.CLOSE_LOOP_ID=B.CLOSE_LOOP_ID
      //   INNER JOIN CLOSE_ADVICE_COLUMN_CONFIG B ON A.CLOSE_LOOP_ID=B.CLOSE_LOOP_ID
      //   WHERE A.CLOSE_LOOP_ID = :CLOSE_LOOP_ID
      // `;
      // 执行参数化查询（防止SQL注入）
      const sql = `
      SELECT 
      TO_CHAR(c.CREATE_TIME, 'yyyy-mm-dd hh24:mi') CREATE_TIME, 
      C.* 
      FROM  CLOSE_LOOP_DOCTOR_ADVICE C 
      where CLOSE_LOOP_ID = :CLOSE_LOOP_ID
      `;
      console.log('实际执行的 SQL:', sql);
      // 使用参数化查询绑定值
      const replacements = { CLOSE_LOOP_ID: closeLoopId };
      const queryResult = await db.query(sql, {
        replacements,
        type: db.QueryTypes.SELECT
      });
  
      // 处理结果
      const data = queryResult[0] || null;
      if (!data) {
        return res.status(404).json({
          code: 404,
          message: 'No data found for this CLOSE_LOOP_ID'
        });
      }
  
      // 返回成功响应
      res.json({
        code: 200,
        data: data,
        message: '闭环医嘱信息获取成功'
      });
  
    } catch (error) {
      console.error('闭环医嘱信息获取失败:', error);
      res.status(500).json({
        code: 500,
        message: 'Internal server error',
        error: error.message
      });
    }
  });
  //获取主节点的数据源信息
  //select * from close_data_base
  router.get('/getCloseLoopDetailBase', async (req, res) => {
    try {
      const sql = `
      SELECT * FROM CLOSE_DATA_BASE
    `;
    const results = await db.query(sql, { type: db.QueryTypes.SELECT });
  
       // 确定 rows 的正确来源
       let rows;
       if (Array.isArray(results) && results.length > 0) {
         // 如果 results 是直接返回的数组（如未包裹在 [rows, metadata] 中）
         rows = results;
       } else if (Array.isArray(results[0])) {
         // 如果 results 是 [rowsArray, metadata] 的形式
         rows = results[0];
       } else {
         // 处理意外情况
         rows = [];
       }
  
      // 验证数据类型和长度
      console.log('原始查询结果:', results); // 输出完整结构
      console.log('数据类型:', Array.isArray(rows) ? '数组' : '非数组');
      console.log('数据长度:', rows?.length); 
  
      // 直接返回原始数据
      res.json({
        code: 200,
        data: rows || [], // 返回原始数据
        message: '成功获取数据源列表'
      });
    } catch (error) {
      console.error('错误:', error);
      res.status(500).json({
        code: 500,
        message: '获取数据源失败'
      });
    }
  });
  

  //获取主闭环的节点绑定字段信息
  router.get('/getCloseLoopDetailYzColumn', async (req, res) => {
    try {
      // 获取查询参数
      const closeLoopId = req.query.CLOSE_LOOP_ID;
  
      // 参数校验
      if (!closeLoopId) {
        return res.status(400).json({
          code: 400,
          message: 'Missing required parameter: CLOSE_LOOP_ID'
        });
      }
  
      // 执行参数化查询（防止SQL注入）
      const sql = `
        SELECT 
              *
              FROM CLOSE_ADVICE_COLUMN_CONFIG A  
        WHERE A.CLOSE_LOOP_ID = :CLOSE_LOOP_ID
        ORDER BY ORDER_NUM ASC 
      `;
      console.log('实际执行的 SQL:', sql);
      // 使用参数化查询绑定值
      const replacements = { CLOSE_LOOP_ID: closeLoopId };
      const queryResult = await db.query(sql, {
        replacements,
        type: db.QueryTypes.SELECT
      });
      // 处理结果
      const data = queryResult;
      if (!data) {
        return res.status(404).json({
          code: 404,
          message: 'No data found for this CLOSE_LOOP_ID'
        });
      }
      // 返回成功响应
      res.json({
        code: 200,
        data: data,
        message: '闭环主医嘱节点获取成功'
      });
  
    } catch (error) {
      console.error('闭环主医嘱节点获取信息失败:', error);
      res.status(500).json({
        code: 500,
        message: 'Internal server error',
        error: error.message
      });
    }
  });



  
  //获取闭环的节点列表
  router.get('/getCloseLoopDetail', async (req, res) => {
    try {
              // 获取查询参数
              const closeLoopId = req.query.CLOSE_LOOP_ID;
          
              // 参数校验
              if (!closeLoopId) {
                return res.status(400).json({
                  code: 400,
                  message: 'Missing required parameter: CLOSE_LOOP_ID'
                });
              }
              // 执行参数化查询（防止SQL注入）
              const sql = `
              select n.* 
              from close_loop_nodes n 
              where CLOSE_LOOP_ID = :CLOSE_LOOP_ID  order by loop_node_order_num asc  
            `;
            console.log('实际执行的 SQL:', sql);

            // 使用参数化查询绑定值
            const replacements = { CLOSE_LOOP_ID: closeLoopId };
            const queryResult = await db.query(sql, {
              replacements,
              type: db.QueryTypes.SELECT
            });
            const data = queryResult;
            if (!data) {
              return res.status(404).json({
                code: 404,
                message: 'No data found for this CLOSE_LOOP_ID'
              });
            }
            // 返回成功响应
            res.json({
              code: 200,
              data: data,
              message: '闭环节点列表获取成功'
            });
 
        } catch (error) {
            console.error('闭环节点列表获取失败:', error);
            res.status(500).json({
              code: 500,
              message: 'Internal server error',
              error: error.message
            });
          }
        });
//获取闭环的明细节点的字段列表
router.get('/getCloseLoopDetailNodes', async (req, res) => {
  try {
            // 获取查询参数
            const NODE_ID = req.query.NODE_ID;
        
            // 参数校验
            if (!NODE_ID) {
              return res.status(400).json({
                code: 400,
                message: 'Missing required parameter: NODE_ID'
              });
            }
            // 执行参数化查询（防止SQL注入）
            const sql = `
            SELECT * FROM 
            close_loop_nodes n 
            where NODE_ID = :NODE_ID
          `;
          console.log('实际执行的 SQL:', sql);
  
          // 使用参数化查询绑定值
          const replacements = { NODE_ID: NODE_ID };
          const queryResult = await db.query(sql, {
            replacements,
            type: db.QueryTypes.SELECT
          });
          const data = queryResult;
          if (!data) {
            return res.status(404).json({
              code: 404,
              message: 'No data found for this NODE_ID'
            });
          }
          // 返回成功响应
          res.json({
            code: 200,
            data: data,
            message: '闭环节点明细获取成功'
          });
  
      } catch (error) {
          console.error('闭环节点明细获取失败:', error);
          res.status(500).json({
            code: 500,
            message: 'Internal server error',
            error: error.message
          });
        }
      });
    
        //获取闭环的明细节点的字段列表
router.get('/getCloseLoopDetailColumn', async (req, res) => {
try {
          // 获取查询参数
          const NODE_ID = req.query.NODE_ID;
      
          // 参数校验
          if (!NODE_ID) {
            return res.status(400).json({
              code: 400,
              message: 'Missing required parameter: NODE_ID'
            });
          }
          // 执行参数化查询（防止SQL注入）
          const sql = `
          select * 
          from close_node_column_config 
          where NODE_ID = :NODE_ID order by order_num asc  
        `;
        console.log('实际执行的 SQL:', sql);

        // 使用参数化查询绑定值
        const replacements = { NODE_ID: NODE_ID };
        const queryResult = await db.query(sql, {
          replacements,
          type: db.QueryTypes.SELECT
        });
        const data = queryResult;
        if (!data) {
          return res.status(404).json({
            code: 404,
            message: 'No data found for this NODE_ID'
          });
        }
        // 返回成功响应
        res.json({
          code: 200,
          data: data,
          message: '闭环节点明细列表获取成功'
        });

    } catch (error) {
        console.error('闭环节点明细列表获取失败:', error);
        res.status(500).json({
          code: 500,
          message: 'Internal server error',
          error: error.message
        });
      }
    });
  
  
  module.exports = router;